package com.hxk.stream;

import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.Collectors;

/**
 * 在jdk1.8后加入了stream编程
 *  在使用Stream编程时，首先要知道4大函数式接口：
 *      1、Consumer<T> 消费型接口，T为出入接口中的值类型
 *      2、Function<T,R> 函数式接口，T为出入接口中的值类型，R为接口执行完毕要返回的值类型
 *      3、Predicate<T> 判断型接口，T为出入接口中的值类型
 *      4、Supplier<T> 供给型接口，T为出入接口中的值类型
 *  本案例将使用Stream处理在给定的用户数据中，找出ID为偶数且年龄大于24且将用户的名称转换为大写且按用户名称倒序排序，只输出一个用户的案例
 *
 */
public class StreamCase {

    public static void main(String[] args) {
        User u1 = new User(11, "a", 23);
        User u2 = new User(12, "b", 24);
        User u3 = new User(13, "c", 22);
        User u4 = new User(14, "d", 28);
        User u5 = new User(16, "e", 26);
        List<User> list = Arrays.asList(u1,u2,u3,u4,u5);
        List<User> list1 = list.stream()//将数据List转换Stream流
                .filter(u->{return u.getId() % 2 == 0;})//ID为偶数
                .filter(u->{return u.getAge() > 24;})//年龄大于24
                .map(u->{u.setName(u.getName().toUpperCase()); return u;})//将用户的名称转换为大写
                .sorted((uu1,uu2)->{return uu2.getName().compareTo(uu1.getName());})//按用户名称倒序排序
                .limit(1)//只输出一个用户
                .collect(Collectors.toList());//将结果转换为List

        list1.forEach(System.out::println);//打印结果
        //testFunction();
        //testPredicate();
        //testSupplier();
        //testConsumer();
    }

    /**
     * 函数式接口
     */
    private static void testFunction(){
        Function<Integer, String> function = new Function<Integer, String>() {
            @Override
            public String apply(Integer integer) {
                return integer+"----------->hello!";
            }
        };
        System.out.println(function.apply(10));

        //将上面修改成lambda表达式方式
        Function<Integer, String> function1 = i -> {return i +"-------->hi!";};
        System.out.println(function1.apply(20));
    }

    /**
     * 判断型接口
     */
    private static void testPredicate(){
        Predicate<String> predicate = new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.isEmpty();
            }
        };
        System.out.println(predicate.test("aaa"));

        //将上面修改成lambda表达式方式
        Predicate<String> predicate1 = s -> {return s.isEmpty();};
        System.out.println(predicate1.test(""));
    }

    /**
     * 供给型接口
     */
    private static void testSupplier(){
        Supplier<String> supplier = new Supplier<String>() {
            @Override
            public String get() {
                return "sup------>";
            }
        };
        System.out.println(supplier.get());

        //将上面修改成lambda表达式方式
        Supplier<String> supplier1 = ()->{return "sup------->1";};
        System.out.println(supplier1.get());
    }

    /**
     * 消费型接口
     */
    private static void testConsumer(){
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s + "------>con");
            }
        };
        consumer.accept("hi");

        //将上面修改成lambda表达式方式
        Consumer<String> consumer1 = s -> {
            System.out.println(s + "-------->con1");
        };
        consumer1.accept("hello");
    }
}
